package 进阶阶段;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * 创建人：刘源江
 * 类描述：
 * 创建时间：2022/8/12 22:18
 **/

public class demo11Collections集合工具类和接口比较器 {
    public static void main(String[] args) {
        //Collections是集合工具类，操作的对象是集合

        //addAll(Collection<T> c, T... elements):往传入集合中添加一些元素。
        //shuffle(List<?> list):随机置换,即可以打乱集合顺序。
        //sort(List<T> list):将集合中元素按照默认规则排序,整数从小到大排序
        //sort(List<T> list，Comparator<? super T> c):将集合中元素按照指定规则排序。

        ArrayList<Integer> list = new ArrayList<Integer>();
        //list.add(12);//就不需要使用add()方法往ArrayList集合里面一个个加入元素
        Collections.addAll(list , 1 , 5 , 65 , 10);
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);

        Collections.sort(list);
        System.out.println(list);//重新排序，整数从小到大排序

        ArrayList<String> listString = new ArrayList<String>();
        Collections.addAll(listString , "bfdg" , "tf" , "afw");
        Collections.sort(listString);
        System.out.println(listString);//重新排序，按照字母表排序，a-z，从小到大

        System.out.println("----------------------------------------------------");

        //Comparator：接口比较器，比较两个对象,谁排在前谁排在后
            //Comparator:也强行对某个对象,进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
            //从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为
            //那些没有自然顺序的对象提供排序。//记忆,外比较器,类的外部自己写规则
        //Integer类型
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
//                return o1 - o2;//从小到大排序
                return o2 - o1;//从大到小排序
            }
        });
        System.out.println(list);

        //String类型，按照字符串的长度排列
        Collections.sort(listString, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();//从短到长排序
//                return o2.length() - o1.length();//从长到短排序
            }
        });
        System.out.println(listString);

        //类需要实现Comparable类才可以去比较类中的元素
            //Comparable：强行对实现它的每个类的对象,进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称
            //为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码,实现自己想要的排序。实现此接口
            //的对象（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键,或有
            //序集合中的元素，无需指定比较器。//记忆,类内部实现比较器,默认规则
        ArrayList<StudentType> listStudentType = new ArrayList<StudentType>();

        listStudentType.add(new StudentType("rose",18));
        listStudentType.add(new StudentType("jack",16));
        listStudentType.add(new StudentType("abc",16));
        listStudentType.add(new StudentType("ace",17));
        listStudentType.add(new StudentType("mark",16));

        Collections.sort(listStudentType, new Comparator<StudentType>() {
            @Override
            public int compare(StudentType o1, StudentType o2) {
//                return o2.getAge()-o1.getAge();//以学生的年龄,降序从大到小排序
                return o1.getAge()-o2.getAge();//以学生的年龄,降序从小到大排序
            }
        });
        System.out.println(listStudentType);

    }
}

class StudentType implements Comparable<StudentType>{
    @Override
    public int compareTo(StudentType o) {
        return this.age-o.age;//升序
    }

    private String name;
    private int age;

    public StudentType() {
    }

    public StudentType(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "StudentType{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
